home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 4 / FM Towns Free Software Collection 4 - Disc 1.iso / t_os / whisper / source / wc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-19  |  18.2 KB  |  864 lines
  1. #include    <stdio.h>
  2. #include    <stdlib.h>
  3. #include    <string.h>
  4. #include    <ctype.h>
  5. #include    <msdos.cf>
  6. #include    <egb.h>
  7. #include    <mos.h>
  8. #include    <snd.h>
  9. #include    "event.h"
  10. #include    "graphic.h"
  11. #include    "msg.h"
  12. #include    "defs.h"
  13. #include    "coldef.h"
  14.  
  15. #define    SECRET        (CMDS_MAX-1)
  16.  
  17. #define    CLIP_UP        10
  18. #define    CLIP_Y        18
  19.  
  20. #define    DRV_X        320
  21. #define    DRV_Y        196
  22.  
  23. #define    FILE_X        404
  24. #define    FILE_Y        36
  25.  
  26. #define    CMDS_X        320
  27. #define    CMDS_Y        36
  28.  
  29. #define    CMDS_MAX    9
  30. #define    CMDS_LEN    8
  31.  
  32. #define    DRV_MAX        17    /* A - Q */
  33. #define    DRV_LEN        8
  34.  
  35. #define    FILE_MAX    25
  36.  
  37. #define    DSP_X        CLIP_UP
  38. #define    DSP_Y        (CLIP_Y+18)
  39. #define    DSP_MAX        25
  40. #define    DSP_LEN        36
  41.  
  42. #define    CLIP_DOWN    (CLIP_UP+CLIP_LEN*8+5)
  43. #define    CLIP_X        (CLIP_DOWN+CLIP_LEN*8+5)
  44. #define    CLIP_EXIT    (CLIP_X+CLIP_SIZ*8+5)
  45.  
  46. #define    CLIP_LEN    2
  47. #define    CLIP_SIZ    26
  48.  
  49. #define    SPC_Y        16
  50. #define    SIZ_Y        11
  51. #define    FNT_SIZ        8        /* 8 or 16 */
  52. #define    FNT_SPC        2
  53.  
  54. #define    WIND_COL    COL_JACK
  55. #define    STD_COL        COL_CHR
  56. #define    W_BAK_COL    COL_JACK
  57. #define    HIT_COL        COL_JACK2
  58. #define    BOX1_COL    COL_LINE
  59.  
  60. #define    ISDIR(c)    (c->att&0x10)
  61.  
  62. #define    IS_FLP        0x00
  63. #define    IS_RES        0x01
  64. #define    IS_SCSI        0x02
  65. #define    IS_RAM        0x03
  66. #define    IS_MDC        0x04
  67. #define    IS_ROM        0x05
  68. #define    IS_CDR        0x06
  69. #define    IS_NON        0xFF
  70.  
  71. typedef struct _WCBUF {
  72.     struct _WCBUF       *next;
  73.     short int        mark;
  74.     short int           att;
  75.     unsigned short int  time,date;
  76.     unsigned long       size;
  77.     char                name[14];
  78. } WCBUF;
  79.  
  80. extern int    errno;
  81.  
  82. int    ESR_setupInfo(char *out_buf);
  83. char    *strdup(char *str);
  84. char    *macget(char *str);
  85.  
  86. static int    CDRV=0;
  87. static int    dir_count=0;
  88. static int    file_count=0;
  89. static int    disk_total_free=0;
  90. static int    disk_write_free=0;
  91. static int    topno=0,now_no=0;
  92. static WCBUF    *topwp=NULL,*now_wp=NULL;
  93. static int    sel_event=ERR;
  94. static char    where[256];
  95. static char    sel_buf[2048];
  96. static char    *file_stack[FILE_MAX];
  97. static unsigned char    drive[]={
  98.     ERR,ERR,ERR,ERR,ERR,ERR,ERR,ERR,
  99.     ERR,ERR,ERR,ERR,ERR,ERR,ERR,ERR,
  100.     ERR,ERR,ERR,ERR,ERR,ERR,ERR,ERR };
  101. static char    *dev_name[]={
  102.     "FDD ","??? ","HDD ","RAM ",
  103.     "MDC ","ROM ","CDR ","??? ",
  104.     "??? ","??? ","??? ","??? " };
  105. static char    *cmds_name[CMDS_MAX]={
  106.      NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL };
  107. static char    *cmds_func[CMDS_MAX]={
  108.      NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL };
  109.  
  110. void    dsp_drive();
  111. void    dsp_all();
  112. void    dsp_file_stack();
  113. void    dsp_one_file();
  114.  
  115. int    dos_err_chk(void)
  116. {
  117.     if ( (Registers.Flags & 0x0001) != 0 ) {
  118.     errno = Registers.AX.R;
  119.     return ERR;
  120.     } else
  121.     return FALSE;
  122. }
  123. int    chdrv(int no)
  124. {
  125.     Registers.AX.R = 0x0E00;
  126.     Registers.DX.R = no;
  127.     calldos();
  128.     return dos_err_chk();
  129. }
  130. int    mkdir(char *name)
  131. {
  132.     Registers.AX.R = 0x3900;
  133.     Registers.DX.R = (int)name;
  134.     Registers.DS.R = getds();
  135.     calldos();
  136.     return dos_err_chk();
  137. }
  138. int    rmdir(char *name)
  139. {
  140.     Registers.AX.R = 0x3A00;
  141.     Registers.DX.R = (int)name;
  142.     Registers.DS.R = getds();
  143.     calldos();
  144.     return dos_err_chk();
  145. }
  146. int    chdir(char *name)
  147. {
  148.     Registers.AX.R = 0x3B00;
  149.     Registers.DX.R = (int)name;
  150.     Registers.DS.R = getds();
  151.     calldos();
  152.     return dos_err_chk();
  153. }
  154. int    getdir(char *name)
  155. {
  156.     Registers.AX.R = 0x4700;
  157.     Registers.DX.R = 0x0000;
  158.     Registers.SI.R = (int)name+3;
  159.     Registers.DS.R = getds();
  160.     calldos();
  161.     if ( dos_err_chk() != 0 )
  162.     return ERR;
  163.  
  164.     Registers.AX.R = 0x1900;
  165.     calldos();
  166.     if ( dos_err_chk() != 0 )
  167.     return ERR;
  168.  
  169.     *(name++) = 'A' + (Registers.AX.R & 0xFF);
  170.     *(name++) = ':';
  171.     *(name++) = '\\';
  172.     if ( *name != '\0' )
  173.     strcat(name,"\\");
  174.  
  175.     return dos_err_chk();
  176. }
  177. void    disk_free(int drv)
  178. {
  179.     Registers.AX.R = 0x3600;
  180.     Registers.DX.R = drv;
  181.     calldos();
  182.     disk_total_free = Registers.DX.R * Registers.AX.R * Registers.CX.R;
  183.     disk_write_free = Registers.BX.R * Registers.AX.R * Registers.CX.R;
  184. }
  185. WCBUF   *wc_read(arg,mode)
  186. char    *arg;
  187. int     mode;
  188. {
  189.     static int   opflg=FALSE;
  190.     static struct {
  191.     unsigned char      dd_dmy[22];
  192.     unsigned short int dd_time,dd_date;
  193.     unsigned long      dd_size;
  194.     char               dd_name[13];
  195.     } dma;
  196.     WCBUF    *wp;
  197.  
  198.     if ( opflg == FALSE ) {
  199.         Registers.AX.R = 0x1A00;
  200.         Registers.DX.R = (int)&dma;
  201.         Registers.DS.R = getds();
  202.         calldos(); 
  203.         Registers.AX.R = 0x4E00;
  204.         Registers.CX.R = mode;
  205.         Registers.DX.R = (int)arg;
  206.         Registers.DS.R = getds();
  207.         opflg = TRUE;
  208.     } else
  209.         Registers.AX.R = 0x4F00;
  210.  
  211.     calldos();
  212.     if ( (Registers.Flags & 0x0001) != 0 ) {
  213.         opflg = FALSE;
  214.     return NULL;
  215.     }
  216.     if ( (wp = (WCBUF *)malloc(sizeof(WCBUF))) != NULL ) {
  217.     wp->next = NULL;
  218.     wp->mark = ERR;
  219.     wp->att = dma.dd_dmy[21];
  220.     wp->date = dma.dd_date;
  221.     wp->time = dma.dd_time;
  222.     wp->size = dma.dd_size;
  223.     strcpy(wp->name,dma.dd_name);
  224.     }
  225.     return wp;
  226. }
  227. char    *subname(name)
  228. register char   *name;
  229. {
  230.     char    *p;
  231.  
  232.     if ( strcmp(name,".") == 0 ||
  233.      strcmp(name,"..") == 0 ||
  234.      (p = strrchr(name,'.')) == NULL )
  235.     while ( *name != '\0' ) name++;
  236.     else
  237.     name = p + 1;
  238.     return name;
  239. }
  240. char    *formname(name)
  241. char    *name;
  242. {
  243.     int     i;
  244.     char    *p;
  245.     static char tmp[16];
  246.  
  247.     p = subname(name);
  248.     if ( *p != '\0' ) p--;
  249.  
  250.     for ( i = 0 ; name < p && i < 8 ; i++ )
  251.     tmp[i] = *(name++);
  252.  
  253.     for ( ; i < 9 ; i++ )
  254.     tmp[i] = ' ';
  255.  
  256.     if ( *p == '.' ) p++;
  257.  
  258.     while ( *p != '\0' )
  259.     tmp[i++] = *(p++);
  260.  
  261.     for ( ; i < 12 ; i++ )
  262.     tmp[i] = ' ';
  263.  
  264.     tmp[i] = '\0';
  265.     return tmp;
  266. }
  267. int     cmpname(sp,dp)
  268. WCBUF   *sp,*dp;
  269. {
  270.     int     cd;
  271.  
  272.     if ( ISDIR(sp) != ISDIR(dp) )
  273.     return ISDIR(sp) ? ERR:TRUE;
  274.     if ( (cd = strcmp(subname(sp->name),subname(dp->name))) != 0 )
  275.     return cd;
  276.     return strcmp(sp->name,dp->name);
  277. }
  278. WCBUF   *wc_sort(sp,dp)
  279. WCBUF   *sp,*dp;
  280. {
  281.     register WCBUF *tp;
  282.     WCBUF tmp;
  283.  
  284.     tp = &tmp;
  285.     if ( (tp->next = sp) == NULL )
  286.     return dp;
  287.     while ( tp->next != NULL ) {
  288.     if ( cmpname(tp->next,dp) >= 0 )
  289.         break;
  290.     tp = tp->next;
  291.     }
  292.     dp->next = tp->next;
  293.     tp->next = dp;
  294.     return tmp.next;
  295. }
  296. void    wc_del(wp)
  297. WCBUF   *wp;
  298. {
  299.     WCBUF   *tp;
  300.  
  301.     while ( wp != NULL ) {
  302.     tp = wp->next;
  303.     free(wp);
  304.     wp = tp;
  305.     }
  306. }
  307. WCBUF   *wc_open()
  308. {
  309.     WCBUF   *wp;
  310.  
  311.     DSP_mos(2);
  312.  
  313.     if ( topwp != NULL )
  314.     wc_del(topwp);
  315.  
  316.     topwp = NULL;
  317.     topno = 0;
  318.     getdir(where);
  319.  
  320.     dir_count = file_count = 0;
  321.     while ( (wp = wc_read("*.*",0x31)) != NULL ) {
  322.     if ( ISDIR(wp) ) dir_count++; else file_count++;
  323.     topwp = wc_sort(topwp,wp);
  324.     }
  325.     disk_free(0);
  326.     DSP_mos(0);
  327.  
  328.     return topwp;
  329. }
  330. void    SEL_file_event(EVENT *ep,int x,int y,int sw)
  331. {
  332.     int     i;
  333.     WCBUF   *wp;
  334.  
  335.     switch(ep->now) {
  336.  
  337.     case EVT_CLIP_MOS:
  338.     EVT_clip_on(ep);
  339.     case EVT_ON_MOS:
  340.     DSP_mos(1);
  341.     break;
  342.  
  343.     case EVT_SELECT_MOS:
  344.     EVT_clip_off(ep);
  345.     DSP_mos(0);
  346.     if ( ep->no == 0 ) {
  347.         sel_event = 3;
  348.         break;
  349.     } else if ( ep->no == (-1) ) {
  350.         sel_event = 2;
  351.         break;
  352.     }
  353.  
  354.     wp = (WCBUF *)(ep->no);
  355.     if ( ISDIR(wp) ) {
  356.         chdir(wp->name);
  357.         wc_open();
  358.         dsp_all(topwp,0);
  359.     } else {
  360.         strcpy(sel_buf,where);
  361.         strcat(sel_buf,wp->name);
  362.  
  363.         if ( wp->mark != FALSE ) {
  364.         for ( i = 0 ; i < FILE_MAX ; i++ ) {
  365.             if ( file_stack[i] != NULL &&
  366.              strcmp(sel_buf,file_stack[i]) == 0 ) {
  367.             free(file_stack[i]);
  368.             file_stack[i] = NULL;
  369.             dsp_file_stack(i);
  370.             break;
  371.             }
  372.         }
  373.         wp->mark = FALSE;
  374.         } else {
  375.             for ( i = 0 ; i < FILE_MAX ; i++ ) {
  376.             if ( file_stack[i] == NULL ) {
  377.             file_stack[i] = strdup(sel_buf);
  378.                 wp->mark = TRUE;
  379.             dsp_file_stack(i);
  380.             break;
  381.             }
  382.         }
  383.         }
  384.         MOS_disp(FALSE);
  385.         dsp_one_file(wp);
  386.         MOS_disp(TRUE);
  387.     }
  388.     break;
  389.  
  390.     case EVT_DOLACK_MOS:
  391.     ep->now = EVT_NON;
  392.     case EVT_MOVE_MOS:
  393.     EVT_clip_off(ep);
  394.     case EVT_OFF_MOS:
  395.     DSP_mos(0);
  396.     break;
  397.     }
  398. }
  399. void    SEL_drv_event(EVENT *ep,int x,int y,int sw)
  400. {
  401.     switch(ep->now) {
  402.  
  403.     case EVT_CLIP_MOS:
  404.     EVT_clip_on(ep);
  405.     case EVT_ON_MOS:
  406.     DSP_mos(1);
  407.     break;
  408.  
  409.     case EVT_SELECT_MOS:
  410.     EVT_clip_off(ep);
  411.     DSP_mos(0);
  412.     chdrv(ep->no);
  413.     CDRV = ep->no;
  414.     dsp_drive();
  415.     wc_open();
  416.     dsp_all(topwp,0);
  417.     break;
  418.  
  419.     case EVT_DOLACK_MOS:
  420.     ep->now = EVT_NON;
  421.     case EVT_MOVE_MOS:
  422.     EVT_clip_off(ep);
  423.     case EVT_OFF_MOS:
  424.     DSP_mos(0);
  425.     break;
  426.     }
  427. }
  428. void    SEL_stack_event(EVENT *ep,int x,int y,int sw)
  429. {
  430.     int     i;
  431.     WCBUF   *wp;
  432.  
  433.     switch(ep->now) {
  434.  
  435.     case EVT_CLIP_MOS:
  436.     EVT_clip_on(ep);
  437.     case EVT_ON_MOS:
  438.     DSP_mos(1);
  439.     break;
  440.  
  441.     case EVT_SELECT_MOS:
  442.     EVT_clip_off(ep);
  443.     DSP_mos(0);
  444.     if ( file_stack[ep->no] != NULL ) {
  445.         for ( wp = topwp ; wp != NULL ; wp = wp->next ) {
  446.         strcpy(sel_buf,where);
  447.         strcat(sel_buf,wp->name);
  448.         if ( strcmp(file_stack[ep->no],sel_buf) == 0 ) {
  449.             wp->mark = FALSE;
  450.                 MOS_disp(FALSE);
  451.                 dsp_one_file(wp);
  452.                 MOS_disp(TRUE);
  453.             break;
  454.         }
  455.         }
  456.         free(file_stack[ep->no]);
  457.         file_stack[ep->no] = NULL;
  458.         MOS_disp(FALSE);
  459.         dsp_file_stack(ep->no);
  460.         MOS_disp(TRUE);
  461.     }
  462.     break;
  463.     
  464.     case EVT_DOLACK_MOS:
  465.     ep->now = EVT_NON;
  466.     case EVT_MOVE_MOS:
  467.     EVT_clip_off(ep);
  468.     case EVT_OFF_MOS:
  469.     DSP_mos(0);
  470.     break;
  471.     }
  472. }
  473. void    SEL_menu_event(EVENT *ep,int x,int y,int sw)
  474. {
  475.     switch(ep->now) {
  476.  
  477.     case EVT_CLIP_MOS:
  478.     EVT_clip_on(ep);
  479.     case EVT_ON_MOS:
  480.     DSP_mos(1);
  481.     break;
  482.  
  483.     case EVT_SELECT_MOS:
  484.     sel_event = ep->no;
  485.     case EVT_DOLACK_MOS:
  486.     ep->now = EVT_NON;
  487.     case EVT_MOVE_MOS:
  488.     EVT_clip_off(ep);
  489.     case EVT_OFF_MOS:
  490.     DSP_mos(0);
  491.     break;
  492.     }
  493. }
  494. void    dsp_name(wp,dmy)
  495. register WCBUF   *wp;
  496. char    *dmy;
  497. {
  498.     sprintf(dmy,"%-12s ",formname(wp->name));
  499.     if ( ISDIR(wp) )
  500.     sprintf(dmy + 13,"   <DIR> ");
  501.     else
  502.     sprintf(dmy + 13,"%8ld ",wp->size);
  503.     sprintf(dmy + 22,"%02d-%02d-%02d %02d:%02d",
  504.     80+(wp->date >> 9),
  505.     (wp->date >> 5) & 0x0F,
  506.     wp->date & 0x1F,
  507.     wp->time >> 11,
  508.     (wp->time >> 5) & 0x3F);
  509. }
  510. void    dsp_one_file(register WCBUF *tp)
  511. {
  512.     int     i;
  513.     register WCBUF *wp;
  514.     char    tmp[80];
  515.  
  516.     wp = now_wp;
  517.     for ( i = 0 ; wp != NULL && i < DSP_MAX ; i++ ) {
  518.     if ( i == 0 && now_no > 0 )
  519.         continue;
  520.     else if ( i == (DSP_MAX - 1) && wp != NULL )
  521.         continue;
  522.  
  523.     else if ( wp == tp ) {
  524.         dsp_name(wp,tmp);
  525.         DSP_box(DSP_X,DSP_Y+i*SPC_Y,
  526.             DSP_X+DSP_LEN*8+4,DSP_Y+i*SPC_Y+SIZ_Y,
  527.             BOX1_COL,
  528.             wp->mark == FALSE ? W_BAK_COL:HIT_COL);
  529.         wrtstr(tmp,
  530.         page_ofs,(DSP_X+FNT_SPC)/2 + (DSP_Y+i*SPC_Y+FNT_SPC)*512,
  531.         col_cnv[STD_COL],
  532.         col_cnv[wp->mark == FALSE ? W_BAK_COL:HIT_COL],FNT_SIZ);
  533.     }
  534.     wp = wp->next;
  535.     }
  536. }
  537.  
  538. void    dsp_all(wp,top)
  539. register WCBUF    *wp;
  540. int    top;
  541. {
  542.     int     i,j,no,cl;
  543.     char    tmp[80];
  544.  
  545.     now_wp = wp;
  546.     now_no = top;
  547.  
  548.     EVT_level_free(300);
  549.  
  550.     MOS_disp(FALSE);
  551.  
  552.     DSP_box(DSP_X-2,DSP_Y-2,
  553.         DSP_X+DSP_LEN*8+4+2,DSP_Y+(DSP_MAX-1)*SPC_Y+SIZ_Y+2,
  554.         BOX1_COL,WIND_COL);
  555.  
  556.     DSP_box(DSP_X-2,DSP_Y+(DSP_MAX-1)*SPC_Y+SIZ_Y+4,
  557.         DSP_X+DSP_LEN*8+4+2,DSP_Y+(DSP_MAX-1)*SPC_Y+SIZ_Y+4+SIZ_Y+2,
  558.         BOX1_COL,WIND_COL);
  559.  
  560.     if ( disk_total_free > 0 ) {
  561.         sprintf(tmp,"%9d/%-9d(%3d%%)%4d/%-4d",
  562.         disk_total_free,disk_write_free,
  563.         100 - ((disk_write_free * 200) /  disk_total_free) / 2,
  564.         file_count,dir_count);
  565.         DSP_string(tmp,DSP_X,DSP_Y+(DSP_MAX-1)*SPC_Y+SIZ_Y+7,
  566.             STD_COL,WIND_COL);
  567.     }
  568.  
  569.     for ( no = i = 0 ; wp != NULL && i < DSP_MAX ; i++ ) {
  570.     if ( i == 0 && top > 0 ) {
  571.         strcpy(tmp,"  ∧    ∧    ∧    ∧    ∧    ∧  ");
  572.         no = 0; cl = HIT_COL;
  573.     } else if ( i == (DSP_MAX - 1) && wp != NULL ) {
  574.         strcpy(tmp,"  ∨    ∨    ∨    ∨    ∨    ∨  ");
  575.         no = (-1); cl = HIT_COL;
  576.     } else {
  577.         dsp_name(wp,tmp);
  578.         no = (int)wp;
  579.         if ( wp->mark == ERR ) {
  580.         wp->mark = FALSE;
  581.         strcpy(sel_buf,where);
  582.         strcat(sel_buf,wp->name);
  583.         for ( j = 0 ; j < FILE_MAX ; j++ ) {
  584.             if ( file_stack[j] != NULL &&
  585.              strcmp(sel_buf,file_stack[j]) == 0 ) {
  586.             wp->mark = TRUE;
  587.             break;
  588.             }
  589.         }
  590.         }
  591.         cl = wp->mark == FALSE ? W_BAK_COL:HIT_COL;
  592.         wp = wp->next;
  593.     }
  594.     EVT_sw(DSP_X,DSP_Y+i*SPC_Y,
  595.         tmp,STD_COL,cl,
  596.         300,SEL_file_event,no);
  597.     }
  598.  
  599.     MOS_disp(TRUE);
  600. }
  601. void    dsp_drive()
  602. {
  603.     int     i,n;
  604.     unsigned char tmp[200];
  605.  
  606.     static int drv_max=ERR;
  607.  
  608.     if ( drv_max == ERR ) {
  609.     ESR_setupInfo((char *)tmp);
  610.     drv_max = 0;
  611.     for ( i = 0 ; i < 16 ; i++ ) {
  612.         if ( (drive[i] = tmp[0x30 + i * 2]) != IS_NON )
  613.         drv_max++;
  614.     }
  615.     drive[2] = IS_NON;    /* C: drive delete */
  616.     drive[16] = IS_CDR;    /* Q: drive apend */
  617.     }
  618.     getdir((char *)tmp);
  619.     CDRV = (tmp[0] - 'A');
  620.  
  621.     EVT_level_free(301);
  622.  
  623.     MOS_disp(FALSE);
  624.  
  625.     DSP_box(DRV_X-2,DRV_Y-2,
  626.         DRV_X+DRV_LEN*8+4+2,DRV_Y+(drv_max-1)*SPC_Y+SIZ_Y+2,
  627.         BOX1_COL,WIND_COL);
  628.  
  629.     for ( i = n = 0 ; i < DRV_MAX ; i++ ) {
  630.     if ( drive[i] != IS_NON ) {
  631.         sprintf((char *)tmp," %c: %s",i + 'A',dev_name[drive[i]]);
  632.         EVT_sw(DRV_X,DRV_Y+n*SPC_Y,
  633.            (char *)tmp,STD_COL,
  634.            i == CDRV ? HIT_COL:W_BAK_COL,
  635.            301,SEL_drv_event,i);
  636.         n++;
  637.     }
  638.     }
  639.     MOS_disp(TRUE);
  640. }
  641. void    dsp_clip()
  642. {
  643.     int     i;
  644.     char    tmp[40];
  645.  
  646.     EVT_level_free(302);
  647.  
  648.     EVT_set_node(JACK_X,2,JACK_X+4*8+4,13,302,SEL_menu_event,0);
  649.     EVT_set_node(HELP_X,2,HELP_X+4*8+4,13,302,SEL_menu_event,5);
  650.     EVT_set_node(EXIT_X,2,EXIT_X+4*8+4,13,302,SEL_menu_event,6);
  651.     EVT_set_node(MIKE_X,2,MIKE_X+4*8+4,13,302,SEL_menu_event,7);
  652.     EVT_set_node(JOHN_X,2,JOHN_X+4*8+4,13,302,SEL_menu_event,8);
  653.     EVT_set_node(KENT_X,2,KENT_X+4*8+4,13,302,SEL_menu_event,9);
  654.  
  655.     MOS_disp(FALSE);
  656.  
  657.     DSP_string("JACK",JACK_X+2,4,COL_CHR,COL_WHIS);
  658.     DSP_box(CMDS_X-2,CMDS_Y-2,
  659.         CMDS_X+CMDS_LEN*8+4+2,CMDS_Y+(CMDS_MAX-1)*SPC_Y+SIZ_Y+2,
  660.         BOX1_COL,WIND_COL);
  661.  
  662.     for ( i = 0 ; i < CMDS_MAX ; i++ ) {
  663.     if ( cmds_name[i] != NULL ) {
  664.         EVT_sw(CMDS_X,CMDS_Y+i*SPC_Y,cmds_name[i],
  665.                i == SECRET ? 6:STD_COL,W_BAK_COL,
  666.                302,SEL_menu_event,10+i);
  667.     }
  668.     }
  669.  
  670.     MOS_disp(TRUE);
  671. }
  672. void    dsp_file_stack(int no)
  673. {
  674.     char    tmp[80];
  675.  
  676.     sprintf(tmp,"%-28.28s",file_stack[no] != NULL ? file_stack[no]:"");
  677.     wrtstr(tmp,
  678.        page_ofs,(FILE_X+FNT_SPC)/2 + (FILE_Y+no*SPC_Y+FNT_SPC) * 512,
  679.        col_cnv[STD_COL],col_cnv[W_BAK_COL],FNT_SIZ);
  680. }
  681. void    dsp_file(void)
  682. {
  683.     int     i;
  684.     char    tmp[80];
  685.  
  686.     EVT_level_free(303);
  687.  
  688.     MOS_disp(FALSE);
  689.  
  690.     DSP_box(FILE_X-2,FILE_Y-2,
  691.         FILE_X+28*8+4+2,FILE_Y+(FILE_MAX-1)*SPC_Y+SIZ_Y+2,
  692.         BOX1_COL,WIND_COL);
  693.  
  694.     for ( i = 0 ; i < FILE_MAX ; i++ ) {
  695.     sprintf(tmp,"%-28.28s",file_stack[i] != NULL ? file_stack[i]:"");
  696.     EVT_sw(FILE_X,FILE_Y+i*SPC_Y,
  697.         tmp,STD_COL,W_BAK_COL,
  698.         303,SEL_stack_event,i);
  699.     }
  700.  
  701.     MOS_disp(TRUE);
  702. }
  703. int    SEL_file(void)
  704. {
  705.     int     i,n,fg=ERR,now_act;
  706.     WCBUF   *wp;
  707.     char    *file=NULL;
  708.     BLOCK   *save[4];
  709.  
  710.     macset("MODE","OPEN");
  711.     now_act = macval("ACTWIND");
  712.     macvalset("ACTWIND",3);
  713.     macvalset("WIND",3);
  714.     MSG_wind(WIND_MSG);
  715.  
  716.     for ( i = 0 ; i < FILE_MAX ; i++ )
  717.     file_stack[i] = NULL;
  718.  
  719. /*********************************
  720.     MOS_disp(FALSE);
  721.     save[0] = DSP_push_vram(CMDS_X-2,CMDS_Y-2,
  722.         CMDS_X+CMDS_LEN*8+4+2,CMDS_Y+(CMDS_MAX-1)*SPC_Y+SIZ_Y+2);
  723.     save[1] = DSP_push_vram(DRV_X-2,DRV_Y-2,
  724.         DRV_X+DRV_LEN*8+4+2,DRV_Y+(DRV_MAX-1)*SPC_Y+SIZ_Y+2);
  725.     save[2] = DSP_push_vram(DSP_X-2,DSP_Y-2,
  726.         DSP_X+DSP_LEN*8+4+2,DSP_Y+(DSP_MAX-1)*SPC_Y+SIZ_Y+2);
  727.     save[3] = DSP_push_vram(FILE_X-2,FILE_Y-2,
  728.         FILE_X+28*8+4+2,FILE_Y+(FILE_MAX-1)*SPC_Y+SIZ_Y+2);
  729. **********************************/
  730.     dsp_clip();
  731.     dsp_drive();
  732.     dsp_file();
  733.     wc_open();
  734.     dsp_all(topwp,0);
  735.  
  736.     for ( ; ; ) {
  737.  
  738.     sel_event = ERR;
  739.     TIME_dsp();
  740.     EVT_loop(300);
  741.  
  742.     if ( sel_event == 0 ) {
  743.         break;
  744.  
  745.     } else if ( sel_event == 5 ) {
  746.         MSG_wind(HELP_MSG);
  747.  
  748.     } else if ( sel_event == 6 ) {
  749.         fg = 6;
  750.         break;
  751.  
  752.     } else if ( sel_event == 7 ) {
  753.         fg = 1;
  754.         break;
  755.  
  756.     } else if ( sel_event == 8 ) {
  757.         fg = 2;
  758.         break;
  759.  
  760.     } else if ( sel_event == 9 ) {
  761.         fg = 3;
  762.         break;
  763.  
  764.     } else if ( sel_event == 2 ) {
  765.         wp = topwp;
  766.         n = topno + (topno > 0 ? (DSP_MAX-2):(DSP_MAX-1));
  767.         for ( i = 0 ; i < n && wp != NULL ; i++ )
  768.             wp = wp->next;
  769.         if ( wp != NULL ) {
  770.         topno = n;
  771.             dsp_all(wp,topno);
  772.         }
  773.  
  774.     } else if ( sel_event == 3 ) {
  775.         if ( topno > 0 ) {
  776.         topno -= (topno > (DSP_MAX-1) ? (DSP_MAX-2):(DSP_MAX-1));
  777.             for ( i = 0 ,wp = topwp ; i < topno && wp != NULL ; i++ )
  778.             wp = wp->next;
  779.             dsp_all(wp,topno);
  780.         }
  781.     } else if ( sel_event >= 10 && sel_event < (CMDS_MAX+10) ) {
  782.         sel_buf[0] = '\0';
  783.         for ( i = 0 ; i < FILE_MAX ; i++ ) {
  784.         if ( file_stack[i] != NULL ) {
  785.             strcat(sel_buf,file_stack[i]);
  786.             strcat(sel_buf," ");
  787.         }
  788.         }
  789.         macset("FILE",sel_buf);
  790.         n = MSG_wind(cmds_func[sel_event-10]);
  791.  
  792.         dsp_clip();
  793.         if ( n == 0 ) {
  794.         for ( i = 0 ; i < FILE_MAX ; i++ ) {
  795.             if ( file_stack[i] != NULL ) {
  796.             free(file_stack[i]);
  797.             file_stack[i] = NULL;
  798.             }
  799.         }
  800.         dsp_drive();
  801.         dsp_file();
  802.         wc_open();
  803.         dsp_all(topwp,0);
  804.         }
  805.     }
  806.  
  807.     }
  808.  
  809.     EVT_level_free(300);
  810.     EVT_level_free(301);
  811.     EVT_level_free(302);
  812.     EVT_level_free(303);
  813.  
  814.     wc_del(topwp);
  815.     topwp = NULL;
  816.  
  817.     for ( i = 0 ; i < FILE_MAX ; i++ ) {
  818.     if ( file_stack[i] != NULL )
  819.         free(file_stack[i]);
  820.     }
  821.  
  822.     MOS_disp(FALSE);
  823. /***************************
  824.     DSP_pop_vram(save[0]);
  825.     DSP_pop_vram(save[1]);
  826.     DSP_pop_vram(save[2]);
  827.     DSP_pop_vram(save[3]);
  828. ****************************/
  829.     DSP_string("JACK",JACK_X+2,4,COL_WHIS2,COL_WHIS);
  830.  
  831.     WIN_resize();
  832.  
  833.     MOS_disp(TRUE);
  834.  
  835.     macset("MODE","CLOSE");
  836.     MSG_wind(WIND_MSG);
  837.     macvalset("ACTWIND",now_act);
  838.  
  839.     return fg;
  840. }
  841. int    CMDS_init(char *argv[])
  842. {
  843.     int     i;
  844.     char    tmp[16];
  845.  
  846.     for ( i = 0 ; i < CMDS_MAX ; i++ ) {
  847.     if ( cmds_name[i] != NULL ) {
  848.         free(cmds_name[i]);
  849.         free(cmds_func[i]);
  850.         cmds_name[i] = NULL;
  851.         cmds_func[i] = NULL;
  852.     }
  853.     if ( *argv != NULL ) {
  854.         if ( *argv[0] != '\0' ) {
  855.         sprintf(tmp,"%-8.8s",*(argv++));
  856.         cmds_name[i] = strdup(tmp);
  857.         cmds_func[i] = strdup(*(argv++));
  858.         } else
  859.         argv += 2;
  860.     }
  861.     }
  862.     return i;
  863. }
  864.